/**
 * 
 * @param {*} imgData 图像
 * @param {*} linePoint [{x:??,y:??},....]
 * @param {*} radius 模糊程度半径
 * @param {*} lineWidth 模糊区域半径大小
 * @param {*} sigma 数值越大周围像素权重越高，越模糊，数值越小周围权重越小，越清晰
 */

export default function gaussBlur(imgData,linePoint,radius = 1,lineWidth = 1,sigma = 5) {
    var pixes = imgData.data; // 像素值
    var width = imgData.width; // 宽
    var height = imgData.height; // 高
    var gaussMatrix = [],  // 高斯矩阵
        gaussSum = 0,
        x,
        r, g, b, a,
        i, j, k, len;


    // G(x,y) = 1 / (2*PI*sigma^2)
    a = 1 / (Math.sqrt(2 * Math.PI) * sigma);
    b = -1 / (2 * sigma * sigma);  
    //生成高斯矩阵
    for (i = 0, x = -radius; x <= radius; x++, i++) {
        g = a * Math.exp(b * x * x);
        gaussMatrix[i] = g;
        gaussSum += g; // 中心点？
    }

    //归一化, 保证高斯矩阵的值在[0,1]之间   (标准化)
    for (i = 0, len = gaussMatrix.length; i < len; i++) {
        gaussMatrix[i] /= gaussSum;
    }

    // linePoint = [{x:??,y:??},....]
    // 对边缘线进行加粗
    let lineLen = linePoint.length;
    let arrXY = [[-1,-1],[0,-1],[1,-1],
                 [-1,0],[0,0],[1,0],
                 [-1,1],[0,1],[1,1]]
    let xyMap = {};
    for( let j = 0; j < lineLen; j++){
        let x = linePoint[j].x;
        let y = linePoint[j].y;
        // for(let i = -lineWidth; i < lineWidth; i++){
        for(let i = 1; i <= lineWidth; i++){
            arrXY.forEach(ele => {
                let _XY = {};
                let _X = x + ele[0] * i;
                let _Y = y + ele[1] * i;
                if(_X >= 0 && _X < width && _Y >= 0 && _Y < width && !xyMap[`x${_X}y${_Y}`]){
                    _XY.x = _X;
                    _XY.y = _Y;
                    linePoint.push(_XY);
                    xyMap[`x${_X}y${_Y}`] = true;
                } 
            })
        }
    }

    linePoint.forEach(ele => {
        let x = ele.x;
        let y = ele.y;
        r = g = b = a = 0;
        gaussSum = 0;
        for (j = -radius; j <= radius; j++) {
            k = x + j;
            if (k >= 0 && k < width) {//确保 k 没超出 x 的范围
                //r,g,b,a 四个一组
                i = (y * width + k) * 4;
                r += pixes[i] * gaussMatrix[j + radius]; // 获得当前点计算权重后的累加值
                g += pixes[i + 1] * gaussMatrix[j + radius];
                b += pixes[i + 2] * gaussMatrix[j + radius];
                a += pixes[i + 3] * gaussMatrix[j + radius];
                // a += pixes[i + 3] * gaussMatrix[j];
                gaussSum += gaussMatrix[j + radius];
            }
        }
        i = (y * width + x) * 4;
        // 除以 gaussSum 是为了消除处于边缘的像素, 高斯运算不足的问题
        // console.log(gaussSum)
        pixes[i] = r / gaussSum;
        pixes[i + 1] = g / gaussSum;
        pixes[i + 2] = b / gaussSum;
        pixes[i + 3] = a / gaussSum;
        // pixes[i + 3] = a ;
    })

    linePoint.forEach(ele => {
        let x = ele.x;
        let y = ele.y;
        r = g = b = a = 0;
        gaussSum = 0;
        for (j = -radius; j <= radius; j++) {
            k = y + j;
            if (k >= 0 && k < height) {//确保 k 没超出 y 的范围
                i = (k * width + x) * 4;
                r += pixes[i] * gaussMatrix[j + radius];
                g += pixes[i + 1] * gaussMatrix[j + radius];
                b += pixes[i + 2] * gaussMatrix[j + radius];
                a += pixes[i + 3] * gaussMatrix[j + radius];
                // a += pixes[i + 3] * gaussMatrix[j];
                gaussSum += gaussMatrix[j + radius];
            }
        }
        i = (y * width + x) * 4;
        pixes[i] = r / gaussSum;
        pixes[i + 1] = g / gaussSum;
        pixes[i + 2] = b / gaussSum;
        pixes[i + 3] = a / gaussSum;
    })

    return imgData;
}

// function blur(linePoint,type,width,height){
//     r = g = b = a = 0;
//     gaussSum = 0;
//     for (j = -radius; j <= radius; j++) {
//         k = y + j;
//         if (k >= 0 && k < height) {//确保 k 没超出 y 的范围
//             i = (k * width + x) * 4;
//             r += pixes[i] * gaussMatrix[j + radius];
//             g += pixes[i + 1] * gaussMatrix[j + radius];
//             b += pixes[i + 2] * gaussMatrix[j + radius];
//             a += pixes[i + 3] * gaussMatrix[j + radius];
//             // a += pixes[i + 3] * gaussMatrix[j];
//             gaussSum += gaussMatrix[j + radius];
//         }
//     }
//     i = (y * width + x) * 4;
//     pixes[i] = r / gaussSum;
//     pixes[i + 1] = g / gaussSum;
//     pixes[i + 2] = b / gaussSum;
//     pixes[i + 3] = a / gaussSum;
// }


    // //x 方向一维高斯运算
    // for (y = 0; y < height; y++) {
    //     for (x = 0; x < width; x++) {
    //         r = g = b = a = 0;
    //         gaussSum = 0;
    //         for (j = -radius; j <= radius; j++) {
    //             k = x + j;
    //             if (k >= 0 && k < width) {//确保 k 没超出 x 的范围
    //                 //r,g,b,a 四个一组
    //                 i = (y * width + k) * 4;
    //                 r += pixes[i] * gaussMatrix[j + radius]; // 获得当前点计算权重后的累加值
    //                 g += pixes[i + 1] * gaussMatrix[j + radius];
    //                 b += pixes[i + 2] * gaussMatrix[j + radius];
    //                 // a += pixes[i + 3] * gaussMatrix[j];
    //                 gaussSum += gaussMatrix[j + radius];
    //             }
    //         }
    //         // 除以 gaussSum 是为了消除处于边缘的像素, 高斯运算不足的问题
    //         // console.log(gaussSum)
    //         i = (y * width + x) * 4;

    //         pixes[i] = r / gaussSum;
    //         pixes[i + 1] = g / gaussSum;
    //         pixes[i + 2] = b / gaussSum;

            
    //         // pixes[i + 3] = a ;
    //     }
    // }
    // //y 方向一维高斯运算
    // for (x = 0; x < width; x++) {
    //     for (y = 0; y < height; y++) {
    //         r = g = b = a = 0;
    //         gaussSum = 0;
    //         for (j = -radius; j <= radius; j++) {
    //             k = y + j;
    //             if (k >= 0 && k < height) {//确保 k 没超出 y 的范围
    //                 i = (k * width + x) * 4;
    //                 r += pixes[i] * gaussMatrix[j + radius];
    //                 g += pixes[i + 1] * gaussMatrix[j + radius];
    //                 b += pixes[i + 2] * gaussMatrix[j + radius];
    //                 // a += pixes[i + 3] * gaussMatrix[j];
    //                 gaussSum += gaussMatrix[j + radius];
    //             }
    //         }
    //         i = (y * width + x) * 4;

    //         pixes[i] = r / gaussSum;
    //         pixes[i + 1] = g / gaussSum;
    //         pixes[i + 2] = b / gaussSum;

    //     }
    // }

// new ImageData(new Uint8ClampedArray(oldImgData.data),oldImgData.width,oldImgData.height);